package cn.edu.ctbu.sbadmin.common.utils;

import cn.edu.ctbu.sbadmin.common.domain.QObject;
import cn.edu.ctbu.sbadmin.common.domain.QueryAndItems;
import cn.edu.ctbu.sbadmin.common.domain.QueryPagePara;
import lombok.extern.slf4j.Slf4j;

import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;

@Slf4j
public class QueryParaHelper {
    static String signalSQL = ",<>,>,<,=,like,";

    public static List<QueryAndItems> WhereToQueryItems(String where) {
        //注意：这个方法只支持and，不支持or
        //  把where条件的参数转为QueryAndItems,默认操作为=号
//        其中,where条件需要我们自己组装.示例:
//        name=张^:like&time=2^:<&dmtCreate=2017-01-01^^2018-01-01
//        这个表示:
//        (name like '%张%' )and ( time<2 ) and (dmtCreate between '2017-01-01' and '2018-01-01)

        return WhereToQueryItems(where, false);//不使用反驼峰
    }

    public static List<QueryAndItems> WhereToQueryItems(String where, Boolean inverCameral) {
        //注意：这个方法只支持and，不支持or
        //  把where条件的参数转为QueryAndItems,默认操作为=号
//        其中,where条件需要我们自己组装.示例:
//        name=张^:like&time=2^:<&dmtCreate=2017-01-01^^2018-01-01
//        这个表示:
//        (name like '%张%' )and ( time<2 ) and (dmtCreate between '2017-01-01' and '2018-01-01)


        // 查询列表数据
        List<QueryAndItems> queryAndItemsList = new ArrayList<QueryAndItems>();


        //(1)按&分成数组
        String[] whereParas = where.split("&");
        QueryAndItems queryAndItems = new QueryAndItems();
        for (String wherePara : whereParas) {

            if (StringUtils.isNotEmpty(wherePara)) {

                //再按=分割
                String[] keyVs = wherePara.split("=");
                String key = keyVs[0];


                String values = keyVs[1];//键值对
                String[] values1 = values.split("\\^:");
                if (values1.length > 1) {
                    //有指定符号，按符号分割
                    String singal = values1[1];//这是符号,只支持
                    if (signalSQL.indexOf("," + singal + ",") >= 0) {
                        //合法参数
                        if (inverCameral) {
                            //是否反驼峰
                            key = Helper.camelToUnderline(key);//反驼峰转换
                        }

                        queryAndItems.pushAndItem(singal, key, "%" + values1[0] + "%", "");

                    } else {
                        //非法参数，去掉
                    }


                } else {
                    //没有了，试着使用^^分割，找between
                    String[] values2 = values.split("\\^\\^");

                    if (inverCameral) {
                        //是否反驼峰
                        key = Helper.camelToUnderline(key);//反驼峰转换
                    }

                    if (values2.length > 1) {


                        //使用between and
                        queryAndItems.pushAndItem("between", key, values2[0], values2[1]);
                    } else {
                        //没有任何分割了，只是使用=号即可。这是默认操作
                        queryAndItems.pushAndItem("=", key, values1[0], "");
                    }

                }


            }

            if (queryAndItems.getSize() > 0) {
                queryAndItemsList.add(queryAndItems);//已经放了内容，加入
            }


        }


        return queryAndItemsList;
    }

    /**
     * 根据参数，生成MQuery对象
     *
     * @param where
     * @param pageSize
     * @param pageIndex
     * @param sort
     * @param direct
     * @return
     * @throws Exception
     */
    public static QueryPagePara GenQuery(String where,
                                         Integer pageSize,
                                         Integer pageIndex,
                                         String sort,
                                         String direct
    ) {

        return GenQuery(where,
                pageSize,
                pageIndex,
                sort,
                direct,
                true);//默认使用反驼峰处理

    }

    /**
     * 根据参数，生成MQuery对象
     *
     * @param where
     * @param pageSize
     * @param pageIndex
     * @param sort
     * @param direct
     * @param invertCameral 是否使用反驼峰，默认不使用
     * @return
     * @throws Exception
     */
    public static QueryPagePara GenQuery(String where,
                                         Integer pageSize,
                                         Integer pageIndex,
                                         String sort,
                                         String direct,
                                         Boolean invertCameral
    ) {
        QueryPagePara mQuery = new QueryPagePara();
        try {
            if (where == null) {
                where = "";
            }
            where = URLDecoder.decode(where, "UTF-8");


            List<QueryAndItems> queryAndItemsList = WhereToQueryItems(where, invertCameral);
            mQuery.setWherePara(queryAndItemsList);

            if (invertCameral) {
                sort = Helper.camelToUnderline(sort);
            }
            mQuery.setSort(sort);
            mQuery.setDirect(direct);
            mQuery.setLimit(pageSize);
            mQuery.setOffset(pageIndex);


        } catch (Exception e) {

            log.error("出错了，GenQuery：" + e.getMessage());

        }

        return mQuery;

    }

    public static <T> QObject WrapQueryObject(T data) {
        QObject<T> myQ = new QObject<>();
        myQ.setDirect(Boolean.getBoolean(ServletUtils.getParameter("isAsc")));

        Integer pageNum = ServletUtils.getParameterToInt("pageNum");
        if(pageNum==null ){
            pageNum  =1;
        }
        myQ.setPageNum(pageNum);
        Integer pageSize =ServletUtils.getParameterToInt("pageSize");
        if(pageSize==null){
            pageSize=10;
        }
        myQ.setPageSize(pageSize);
        myQ.setSort(ServletUtils.getParameter("orderByColumn"));
        if (data != null){
            myQ.setData(data);
        }


        return myQ;

    }


}
